{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Installation\n",
    "! pip install smolagents\n",
    "# To install from source instead of the last release, comment the command above and uncomment the following one.\n",
    "# ! pip install git+https://github.com/huggingface/smolagents.git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "यहाँ, हम एडवांस्ड tools उपयोग देखेंगे।\n",
    "\n",
    "> [!TIP]\n",
    "> यदि आप एजेंट्स बनाने में नए हैं, तो सबसे पहले [एजेंट्स का परिचय](https://huggingface.co/docs/smolagents/main/hi/tutorials/../conceptual_guides/intro_agents) और [smolagents की गाइडेड टूर](https://huggingface.co/docs/smolagents/main/hi/tutorials/../guided_tour) पढ़ना सुनिश्चित करें।\n",
    "\n",
    "- [Tools](#tools)\n",
    "    - [टूल क्या है, और इसे कैसे बनाएं?](#टूल-क्या-है-और-इसे-कैसे-बनाएं)\n",
    "    - [अपना टूल हब पर शेयर करें](#अपना-टूल-हब-पर-शेयर-करें)\n",
    "    - [स्पेस को टूल के रूप में इम्पोर्ट करें](#स्पेस-को-टूल-के-रूप-में-इम्पोर्ट-करें)\n",
    "    - [LangChain टूल्स का उपयोग करें](#LangChain-टूल्स-का-उपयोग-करें)\n",
    "    - [अपने एजेंट के टूलबॉक्स को मैनेज करें](#अपने-एजेंट-के-टूलबॉक्स-को-मैनेज-करें)\n",
    "    - [टूल्स का कलेक्शन उपयोग करें](#टूल्स-का-कलेक्शन-उपयोग-करें)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### टूल क्या है और इसे कैसे बनाएं"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "टूल मुख्य रूप से एक फ़ंक्शन है जिसे एक LLM एजेंटिक सिस्टम में उपयोग कर सकता है।\n",
    "\n",
    "लेकिन इसका उपयोग करने के लिए, LLM को एक API दी जाएगी: नाम, टूल विवरण, इनपुट प्रकार और विवरण, आउटपुट प्रकार।\n",
    "\n",
    "इसलिए यह केवल एक फ़ंक्शन नहीं हो सकता। यह एक क्लास होनी चाहिए।\n",
    "\n",
    "तो मूल रूप से, टूल एक क्लास है जो एक फ़ंक्शन को मेटाडेटा के साथ रैप करती है जो LLM को समझने में मदद करती है कि इसका उपयोग कैसे करें।\n",
    "\n",
    "यह कैसा दिखता है:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from smolagents import Tool\n",
    "\n",
    "class HFModelDownloadsTool(Tool):\n",
    "    name = \"model_download_counter\"\n",
    "    description = \"\"\"\n",
    "    This is a tool that returns the most downloaded model of a given task on the Hugging Face Hub.\n",
    "    It returns the name of the checkpoint.\"\"\"\n",
    "    inputs = {\n",
    "        \"task\": {\n",
    "            \"type\": \"string\",\n",
    "            \"description\": \"the task category (such as text-classification, depth-estimation, etc)\",\n",
    "        }\n",
    "    }\n",
    "    output_type = \"string\"\n",
    "\n",
    "    def forward(self, task: str):\n",
    "        from huggingface_hub import list_models\n",
    "\n",
    "        model = next(iter(list_models(filter=task, sort=\"downloads\", direction=-1)))\n",
    "        return model.id\n",
    "\n",
    "model_downloads_tool = HFModelDownloadsTool()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "कस्टम टूल `Tool` को सबक्लास करता है उपयोगी मेथड्स को इनहेरिट करने के लिए। चाइल्ड क्लास भी परिभाषित करती है:\n",
    "- एक `name` एट्रिब्यूट, जो टूल के नाम से संबंधित है। नाम आमतौर पर बताता है कि टूल क्या करता है। चूंकि कोड एक टास्क के लिए सबसे अधिक डाउनलोड वाले मॉडल को रिटर्न करता है, इसलिए इसे `model_download_counter` नाम दें।\n",
    "- एक `description` एट्रिब्यूट एजेंट के सिस्टम प्रॉम्प्ट को पॉपुलेट करने के लिए उपयोग किया जाता है।\n",
    "- एक `inputs` एट्रिब्यूट, जो `\"type\"` और `\"description\"` keys वाला डिक्शनरी है। इसमें जानकारी होती है जो पायथन इंटरप्रेटर को इनपुट के बारे में शिक्षित विकल्प चुनने में मदद करती है।\n",
    "- एक `output_type` एट्रिब्यूट, जो आउटपुट टाइप को निर्दिष्ट करता है। `inputs` और `output_type` दोनों के लिए टाइप [Pydantic formats](https://docs.pydantic.dev/latest/concepts/json_schema/#generating-json-schema) होने चाहिए, वे इनमें से कोई भी हो सकते हैं: `[\"string\", \"boolean\",\"integer\", \"number\", \"image\", \"audio\", \"array\", \"object\", \"any\", \"null\"]`।\n",
    "- एक `forward` मेथड जिसमें एक्जीक्यूट किया जाने वाला इन्फरेंस कोड होता है।\n",
    "\n",
    "एजेंट में उपयोग किए जाने के लिए इतना ही चाहिए!\n",
    "\n",
    "टूल बनाने का एक और तरीका है। [guided_tour](https://huggingface.co/docs/smolagents/main/hi/tutorials/../guided_tour) में, हमने `@tool` डेकोरेटर का उपयोग करके एक टूल को लागू किया। [tool()](https://huggingface.co/docs/smolagents/main/hi/reference/tools#smolagents.tool) डेकोरेटर सरल टूल्स को परिभाषित करने का अनुशंसित तरीका है, लेकिन कभी-कभी आपको इससे अधिक की आवश्यकता होती है: अधिक स्पष्टता के लिए एक क्लास में कई मेथड्स का उपयोग करना, या अतिरिक्त क्लास एट्रिब्यूट्स का उपयोग करना।\n",
    "\n",
    "इस स्थिति में, आप ऊपर बताए अनुसार [Tool](https://huggingface.co/docs/smolagents/main/hi/reference/tools#smolagents.Tool) को सबक्लास करके अपना टूल बना सकते हैं।"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### अपना टूल हब पर शेयर करें"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "आप टूल पर [push_to_hub()](https://huggingface.co/docs/smolagents/main/hi/reference/tools#smolagents.Tool.push_to_hub) को कॉल करके अपना कस्टम टूल हब पर शेयर कर सकते हैं। सुनिश्चित करें कि आपने हब पर इसके लिए एक रिपॉजिटरी बनाई है और आप रीड एक्सेस वाला टोकन उपयोग कर रहे हैं।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_downloads_tool.push_to_hub(\"{your_username}/hf-model-downloads\", token=\"<YOUR_HUGGINGFACEHUB_API_TOKEN>\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "हब पर पुश करने के लिए काम करने के लिए, आपके टूल को कुछ नियमों का पालन करना होगा:\n",
    "- सभी मेथड्स सेल्फ-कंटेन्ड हैं, यानी उनके आर्ग्स से आने वाले वेरिएबल्स का उपयोग करें।\n",
    "- उपरोक्त बिंदु के अनुसार, **सभी इम्पोर्ट्स को सीधे टूल के फ़ंक्शंस के भीतर परिभाषित किया जाना चाहिए**, अन्यथा आपको अपने कस्टम टूल के साथ [save()](https://huggingface.co/docs/smolagents/main/hi/reference/tools#smolagents.Tool.save) या [push_to_hub()](https://huggingface.co/docs/smolagents/main/hi/reference/tools#smolagents.Tool.push_to_hub) को कॉल करने का प्रयास करते समय एरर मिलेगा।\n",
    "- यदि आप `__init__` विधि को सबक्लास करते हैं, तो आप इसे `self` के अलावा कोई अन्य आर्ग्यूमेंट नहीं दे सकते। ऐसा इसलिए है क्योंकि किसी विशिष्ट टूल इंस्टेंस के इनिशियलाइजेशन के दौरान सेट किए गए तर्कों को आर्ग्यूमेंट्स करना कठिन होता है, जो उन्हें हब पर ठीक से साझा करने से रोकता है। और वैसे भी, एक विशिष्ट क्लास बनाने का विचार यह है कि आप हार्ड-कोड के लिए आवश्यक किसी भी चीज़ के लिए क्लास विशेषताएँ पहले से ही सेट कर सकते हैं (बस `your_variable=(...)` को सीधे `class YourTool(Tool):` पंक्ति के अंतर्गत सेट करें ). और निश्चित रूप से आप अभी भी `self.your_variable` को असाइन करके अपने कोड में कहीं भी एक क्लास विशेषता बना सकते हैं।\n",
    "\n",
    "\n",
    "एक बार जब आपका टूल हब पर पुश हो जाता है, तो आप इसे विज़ुअलाइज़ कर सकते हैं। [यहाँ](https://huggingface.co/spaces/m-ric/hf-model-downloads) `model_downloads_tool` है जिसे मैंने पुश किया है। इसमें एक अच्छा ग्रेडियो इंटरफ़ेस है।\n",
    "\n",
    "टूल फ़ाइलों में गहराई से जाने पर, आप पा सकते हैं कि सारी टूल लॉजिक [tool.py](https://huggingface.co/spaces/m-ric/hf-model-downloads/blob/main/tool.py) के अंतर्गत है। यहीं आप किसी और द्वारा शेयर किए गए टूल का निरीक्षण कर सकते हैं।\n",
    "\n",
    "फिर आप टूल को [load_tool()](https://huggingface.co/docs/smolagents/main/hi/reference/tools#smolagents.load_tool) के साथ लोड कर सकते हैं या [from_hub()](https://huggingface.co/docs/smolagents/main/hi/reference/tools#smolagents.Tool.from_hub) के साथ बना सकते हैं और इसे अपने एजेंट में `tools` पैरामीटर में पास कर सकते हैं।\n",
    "चूंकि टूल्स को चलाने का मतलब कस्टम कोड चलाना है, आपको यह सुनिश्चित करना होगा कि आप रिपॉजिटरी पर भरोसा करते हैं, इसलिए हम हब से टूल लोड करने के लिए `trust_remote_code=True` पास करने की आवश्यकता रखते हैं।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from smolagents import load_tool, CodeAgent\n",
    "\n",
    "model_download_tool = load_tool(\n",
    "    \"{your_username}/hf-model-downloads\",\n",
    "    trust_remote_code=True\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### स्पेस को टूल के रूप में इम्पोर्ट करें"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "आप [Tool.from_space()](https://huggingface.co/docs/smolagents/main/hi/reference/tools#smolagents.Tool.from_space) मेथड का उपयोग करके हब से एक स्पेस को सीधे टूल के रूप में इम्पोर्ट कर सकते हैं!\n",
    "\n",
    "आपको केवल हब पर स्पेस की ID, इसका नाम, और एक विवरण प्रदान करने की आवश्यकता है जो आपके एजेंट को समझने में मदद करेगा कि टूल क्या करता है। अंदर से, यह स्पेस को कॉल करने के लिए [`gradio-client`](https://pypi.org/project/gradio-client/) लाइब्रेरी का उपयोग करेगा।\n",
    "\n",
    "उदाहरण के लिए, चलिए हब से [FLUX.1-dev](https://huggingface.co/black-forest-labs/FLUX.1-dev) स्पेस को इम्पोर्ट करें और इसका उपयोग एक इमेज जनरेट करने के लिए करें।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_generation_tool = Tool.from_space(\n",
    "    \"black-forest-labs/FLUX.1-schnell\",\n",
    "    name=\"image_generator\",\n",
    "    description=\"Generate an image from a prompt\"\n",
    ")\n",
    "\n",
    "image_generation_tool(\"A sunny beach\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "और देखो, यह तुम्हारी छवि है! 🏖️\n",
    "\n",
    "<img src=\"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/sunny_beach.webp\">\n",
    "\n",
    "फिर आप इस टूल का उपयोग किसी अन्य टूल की तरह कर सकते हैं। उदाहरण के लिए, चलिए प्रॉम्प्ट `a rabbit wearing a space suit` को सुधारें और इसकी एक इमेज जनरेट करें। यह उदाहरण यह भी दिखाता है कि आप एजेंट को अतिरिक्त आर्ग्यूमेंट्स कैसे पास कर सकते हैं।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from smolagents import CodeAgent, InferenceClientModel\n",
    "\n",
    "model = InferenceClientModel(model_id=\"Qwen/Qwen3-Next-80B-A3B-Thinking\")\n",
    "agent = CodeAgent(tools=[image_generation_tool], model=model)\n",
    "\n",
    "agent.run(\n",
    "    \"Improve this prompt, then generate an image of it.\", additional_args={'user_prompt': 'A rabbit wearing a space suit'}\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```text\n",
    "=== Agent thoughts:\n",
    "improved_prompt could be \"A bright blue space suit wearing rabbit, on the surface of the moon, under a bright orange sunset, with the Earth visible in the background\"\n",
    "\n",
    "Now that I have improved the prompt, I can use the image generator tool to generate an image based on this prompt.\n",
    ">>> Agent is executing the code below:\n",
    "image = image_generator(prompt=\"A bright blue space suit wearing rabbit, on the surface of the moon, under a bright orange sunset, with the Earth visible in the background\")\n",
    "final_answer(image)\n",
    "```\n",
    "\n",
    "<img src=\"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/rabbit_spacesuit_flux.webp\">\n",
    "\n",
    "यह कितना कूल है? 🤩"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LangChain टूल्स का उपयोग करें"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "हम LangChain को पसंद करते हैं और मानते हैं कि इसके पास टूल्स का एक बहुत आकर्षक संग्रह है।\n",
    "LangChain से एक टूल इम्पोर्ट करने के लिए, `from_langchain()` मेथड का उपयोग करें।\n",
    "\n",
    "यहाँ बताया गया है कि आप LangChain वेब सर्च टूल का उपयोग करके परिचय के सर्च रिजल्ट को कैसे फिर से बना सकते हैं।\n",
    "इस टूल को काम करने के लिए `pip install langchain google-search-results -q` की आवश्यकता होगी।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.agents import load_tools\n",
    "\n",
    "search_tool = Tool.from_langchain(load_tools([\"serpapi\"])[0])\n",
    "\n",
    "agent = CodeAgent(tools=[search_tool], model=model)\n",
    "\n",
    "agent.run(\"How many more blocks (also denoted as layers) are in BERT base encoder compared to the encoder from the architecture proposed in Attention is All You Need?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### अपने एजेंट के टूलबॉक्स को मैनेज करें"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "आप एजेंट के टूलबॉक्स को `agent.tools` एट्रिब्यूट में एक टूल जोड़कर या बदलकर मैनेज कर सकते हैं, क्योंकि यह एक स्टैंडर्ड डिक्शनरी है।\n",
    "\n",
    "चलिए केवल डिफ़ॉल्ट टूलबॉक्स के साथ इनिशियलाइज़ किए गए मौजूदा एजेंट में `model_download_tool` जोड़ें।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from smolagents import InferenceClientModel\n",
    "\n",
    "model = InferenceClientModel(model_id=\"Qwen/Qwen3-Next-80B-A3B-Thinking\")\n",
    "\n",
    "agent = CodeAgent(tools=[], model=model, add_base_tools=True)\n",
    "agent.tools[model_download_tool.name] = model_download_tool"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "अब हम नए टूल का लाभ उठा सकते हैं।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent.run(\n",
    "    \"Can you give me the name of the model that has the most downloads in the 'text-to-video' task on the Hugging Face Hub but reverse the letters?\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> [!TIP]\n",
    "> एजेंट में बहुत अधिक टूल्स न जोड़ने से सावधान रहें: यह कमजोर LLM इंजन को ओवरव्हेल्म कर सकता है।"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### टूल्स का कलेक्शन उपयोग करें"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "आप `ToolCollection` ऑब्जेक्ट का उपयोग करके टूल कलेक्शंस का लाभ उठा सकते हैं। यह या तो हब से एक कलेक्शन या MCP सर्वर टूल्स को लोड करने का समर्थन करता है।"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### हब में कलेक्शन से टूल कलेक्शन"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "आप उस कलेक्शन के स्लग के साथ इसका लाभ उठा सकते हैं जिसका आप उपयोग करना चाहते हैं।\n",
    "फिर उन्हें अपने एजेंट को इनिशियलाइज़ करने के लिए एक लिस्ट के रूप में पास करें, और उनका उपयोग शुरू करें!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from smolagents import ToolCollection, CodeAgent\n",
    "\n",
    "image_tool_collection = ToolCollection.from_hub(\n",
    "    collection_slug=\"huggingface-tools/diffusion-tools-6630bb19a942c2306a2cdb6f\",\n",
    "    token=\"<YOUR_HUGGINGFACEHUB_API_TOKEN>\"\n",
    ")\n",
    "agent = CodeAgent(tools=[*image_tool_collection.tools], model=model, add_base_tools=True)\n",
    "\n",
    "agent.run(\"Please draw me a picture of rivers and lakes.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "स्टार्ट को तेज करने के लिए, टूल्स केवल तभी लोड होते हैं जब एजेंट द्वारा कॉल किए जाते हैं।"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### किसी भी MCP सर्वर से टूल कलेक्शन"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[glama.ai](https://glama.ai/mcp/servers) या [smithery.ai](https://smithery.ai/) पर उपलब्ध सैकड़ों MCP सर्वर्स से टूल्स का लाभ उठाएं।\n",
    "\n",
    "MCP सर्वर्स टूल्स को निम्नानुसार `ToolCollection` ऑब्जेक्ट में लोड किया जा सकता है:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from smolagents import ToolCollection, CodeAgent\n",
    "from mcp import StdioServerParameters\n",
    "\n",
    "server_parameters = StdioServerParameters(\n",
    "    command=\"uv\",\n",
    "    args=[\"--quiet\", \"pubmedmcp@0.1.3\"],\n",
    "    env={\"UV_PYTHON\": \"3.12\", **os.environ},\n",
    ")\n",
    "\n",
    "with ToolCollection.from_mcp(server_parameters, trust_remote_code=True) as tool_collection:\n",
    "    agent = CodeAgent(tools=[*tool_collection.tools], add_base_tools=True)\n",
    "    agent.run(\"Please find a remedy for hangover.\")"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 4
}
